package com.maint.m.utils

import android.content.Context
import android.os.Bundle
import android.util.Log
import com.iflytek.cloud.ErrorCode
import com.iflytek.cloud.InitListener
import com.iflytek.cloud.SpeechConstant
import com.iflytek.cloud.SpeechError
import com.iflytek.cloud.SpeechSynthesizer
import com.iflytek.cloud.SynthesizerListener

object XunfeiTtsUtil {

    private val TAG = "XunfeiTtsUtil"
    private var synthesizer: SpeechSynthesizer? = null
    private var isInitialized = false

    /**
     * 初始化科大讯飞TTS引擎
     * @param context 上下文
     * @param onInitComplete 初始化完成回调
     */
    fun init(context: Context, onInitComplete: (Boolean, String?) -> Unit) {
        try {
            Log.i(TAG, "开始初始化科大讯飞TTS引擎")
            
            val initListener = InitListener {
                code ->
                if (code == ErrorCode.SUCCESS) {
                    Log.i(TAG, "科大讯飞TTS引擎初始化成功")
                    isInitialized = true
                    
                    // 初始化成功后设置参数 - 简化配置，避免离线引擎错误
                    synthesizer?.apply {
                        try {
                            // 首先尝试使用在线引擎配置（避免离线引擎错误码24000）
                            setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD)
                            setParameter(SpeechConstant.VOICE_NAME, "xiaoyan")
                            
                            // 设置音频参数
                            setParameter(SpeechConstant.SPEED, "50")
                            setParameter(SpeechConstant.VOLUME, "80")
                            setParameter(SpeechConstant.PITCH, "50")
                            setParameter(SpeechConstant.AUDIO_FORMAT, "wav")
                            setParameter(SpeechConstant.TTS_AUDIO_PATH, "-")
                            
                            Log.i(TAG, "TTS参数配置完成（使用在线引擎）")
                        } catch (e: Exception) {
                            Log.e(TAG, "配置TTS参数时出现异常", e)
                        }
                    }
                    onInitComplete(true, null)
                } else {
                    Log.e(TAG, "科大讯飞TTS引擎初始化失败，错误码: $code")
                    onInitComplete(false, "初始化失败: $code")
                }
            }

            synthesizer = SpeechSynthesizer.createSynthesizer(context, initListener)
        } catch (e: Exception) {
            Log.e(TAG, "初始化TTS引擎时出现异常", e)
            onInitComplete(false, "初始化异常: ${e.message}")
        }
    }

    /**
     * 将文本转换为音频数据
     * @param text 要转换的文本
     * @param onAudioReady 音频数据准备好的回调
     * @param onError 错误回调
     */
    fun textToAudio(
        text: String,
        onAudioReady: (ByteArray) -> Unit,
        onError: (String) -> Unit
    ) {
        if (!ensureTtsAvailable()) {
            onError("TTS引擎未初始化或不可用，请先调用init方法")
            return
        }

        if (text.isBlank()) {
            onError("文本不能为空")
            return
        }

        try {
            // 首先确保TTS引擎配置正确，设置为直接输出音频数据而不是播放
            synthesizer?.apply {
                // 关键设置：使用合成模式而不是播放模式
                setParameter(SpeechConstant.TTS_AUDIO_PATH, "")
                // 确保使用正确的音频格式
                setParameter(SpeechConstant.AUDIO_FORMAT, "wav")
                // 设置采样率为16kHz，这是常用的音频采样率
                setParameter(SpeechConstant.SAMPLE_RATE, "16000")
            }
            
            // 创建临时文件保存音频数据
            val tempAudioFile = java.io.File.createTempFile("tts_audio", ".wav")
            tempAudioFile.deleteOnExit() // 程序退出时自动删除
            
            // 设置TTS引擎将音频数据保存到临时文件
            synthesizer?.setParameter(SpeechConstant.TTS_AUDIO_PATH, tempAudioFile.absolutePath)
            
            val synthesizerListener = object : SynthesizerListener {
                override fun onSpeakBegin() {
                    Log.i(TAG, "开始合成语音")
                }

                override fun onBufferProgress(percent: Int, beginPos: Int, endPos: Int, info: String?) {
                    Log.i(TAG, "缓冲进度: $percent%, 文本位置: $beginPos-$endPos, 信息: $info")
                }

                override fun onSpeakPaused() {
                    Log.i(TAG, "语音合成暂停")
                }

                override fun onSpeakResumed() {
                    Log.i(TAG, "语音合成恢复")
                }

                override fun onSpeakProgress(progress: Int, beginPos: Int, endPos: Int) {
                    Log.i(TAG, "合成进度: $progress%, 文本位置: $beginPos-$endPos")
                }

                override fun onCompleted(error: SpeechError?) {
                    try {
                        if (error == null) {
                            // 语音合成成功完成，从临时文件读取音频数据
                            if (tempAudioFile.exists() && tempAudioFile.length() > 0) {
                                val audioData = tempAudioFile.readBytes()
                                Log.i(TAG, "语音合成完成，从文件读取音频数据，长度: ${audioData.size}字节")
                                onAudioReady(audioData)
                            } else {
                                Log.e(TAG, "语音合成完成，但临时文件不存在或为空")
                                onError("合成的音频数据为空")
                            }
                        } else {
                            Log.e(TAG, "语音合成完成但有错误", error)
                            onError("合成失败: ${error.errorDescription}")
                        }
                    } catch (e: Exception) {
                        Log.e(TAG, "读取临时音频文件时出错", e)
                        onError("读取音频数据失败: ${e.message}")
                    } finally {
                        // 确保删除临时文件
                        try {
                            tempAudioFile.delete()
                        } catch (ignored: Exception) {}
                    }
                }

                override fun onEvent(eventType: Int, arg1: Int, arg2: Int, obj: Bundle?) {
                    // 基本日志记录，但不再依赖此方法获取音频数据
                    Log.i(TAG, "事件: $eventType, arg1: $arg1, arg2: $arg2")
                }
            }

            val code = synthesizer?.startSpeaking(text, synthesizerListener) ?: -1
            if (code != ErrorCode.SUCCESS) {
                Log.e(TAG, "启动语音合成失败，错误码: $code")
                onError("启动合成失败: $code")
            }
        } catch (e: Exception) {
            Log.e(TAG, "文本转音频过程中出现异常", e)
            onError("处理异常: ${e.message}")
        }
    }

    /**
     * 释放TTS资源
     */
    fun release() {
        try {
            synthesizer?.destroy()
            synthesizer = null
            isInitialized = false
            Log.i(TAG, "TTS资源已释放")
        } catch (e: Exception) {
            Log.e(TAG, "释放TTS资源失败", e)
        }
    }

    /**
     * 简化版本：不再尝试使用离线引擎，避免错误码24000
     * 错误码24000通常表示：本地引擎不可用、未安装或配置错误
     */
    fun ensureTtsAvailable(): Boolean {
        return isInitialized && synthesizer != null
    }
}